#!/usr/bin/env python
# -*- coding: UTF8 	-*-

from GladeConnect import GladeConnect
import gtk
import sys
import time
import datetime
import dialogos
import debugwindow
import SimpleTree
import ifd
from strSQL.embotellado import strSelectEmbotellado, strSelectFiltroEmbotellado
from strSQL.basicas import strNextValCodigo

from psycopg2 import connect
import completion
import comunes
from pyBusqueda import pyBusqueda
import proceso
import treetohtml

(CODIGO_EMBOTELLADO,
 CODIGO_PRODUCTO,
 DESCRIPCION_PRODUCTO,
 FECHA,
 HORA,
 CANTIDADO_EMBOTELLADO,
 LOTE,
 CANTIDAD_BOTELLA,
 OBSERVACION,
 CODIGO_TEMPORADA,
 DESCRIPCION_TEMPORADA) = range(11)

class wnEmbotellado(GladeConnect):
    def __init__(self, conexion=None, padre=None, root="wnProceso"):
        GladeConnect.__init__(self, "glade/wnProceso.glade", root)
        if padre is None:
            self.wnProceso.set_title("Embotellado")
        self.cnx = conexion
        self.cursor = self.cnx.cursor()
        self.padre = padre
        if padre is None :
            self.wnProceso.maximize()
            self.frm_padre = self.wnProceso
            self.padre 
        else:
            self.frm_padre = padre.frm_padre
            
        self.crea_columnas()
        self.carga_datos()
        
    def crea_columnas(self):
        columnas = []
        columnas.append ([CODIGO_EMBOTELLADO, "Código", "str"])
        columnas.append ([DESCRIPCION_PRODUCTO, "Producto", "str"])
        columnas.append ([FECHA, "Fecha","dte"])
        columnas.append ([HORA, "Hora","time"])
        columnas.append ([CANTIDADO_EMBOTELLADO, "Cantidad", "str"])
        columnas.append ([LOTE, "Lote", "str"])
        columnas.append([CANTIDAD_BOTELLA, "Cantidad de Botella", "str"])
        columnas.append ([OBSERVACION, "Observación", "str"])
        columnas.append ([DESCRIPCION_TEMPORADA, "Temporada", "str"])
        
        self.carga_datos()
        SimpleTree.GenColsByModel(self.modelo, columnas, self.treeProceso)
        self.col_data = [x[0] for x in columnas]
        
    def on_btnImprimir_clicked(self, btn=None):
        t = treetohtml.TreeToHTML(self.treeProceso,"Embotellado", self.col_data)
        t.show()
        
    def carga_datos(self):
        self.modelo = ifd.ListStoreFromSQL(self.cnx, strSelectEmbotellado)
        self.treeProceso.set_model(self.modelo)

    def on_btnAnadir_clicked(self, btn=None, data=None):
        dlg = dlgEmbotellado(self.cnx, self.frm_padre, False)
        dlg.editando = False
        dlg.entFecha.set_date(datetime.date.today())
        response = dlg.dlgEmbotellado.run()
        if response == gtk.RESPONSE_OK:
            self.carga_datos()
    
    def on_btnQuitar_clicked(self, btn=None):
        model, it = self.treeProceso.get_selection().get_selected()
        if model is None or it is None:
            return
        
        selection = self.treeProceso.get_selection()
        model, it = selection.get_selected()
        codigo = model.get_value(it, CODIGO_EMBOTELLADO)
        producto = model.get_value(it, DESCRIPCION_PRODUCTO)
        fecha = model.get_value(it, FECHA).split()[0]
        
        if dialogos.yesno("¿Desea eliminar la Embotellado <b>%s, Producto %s del %s</b>?\nEsta acción no se puede deshacer\n" % (codigo, producto, fecha), self.frm_padre) == gtk.RESPONSE_YES:
            llaves = {'CODIGO_EMBOTELLADO':codigo}
            sql = ifd.deleteFromDict('traza.embotellado', llaves)
            try:
                self.cursor.execute(sql, llaves)
                model.remove(it)
            except:
                print sys.exc_info()[1]
                dialogos.error("<b>NO SE PUEDE ELIMINAR</b>\nEl Embotellado de <b>%s</b> se encuentra relacionado con Módulo Producto. "%producto)
            
        
    def on_btnPropiedades_clicked(self, btn=None):
        model, it = self.treeProceso.get_selection().get_selected()
        if model is None or it is None:
            return
        
        dlg = dlgEmbotellado(self.cnx, self.frm_padre, False, codigo_embotellado=model.get_value(it, CODIGO_EMBOTELLADO))
        dlg.entCodigoEmbotellado.set_text(model.get_value(it, CODIGO_EMBOTELLADO))
        dlg.codigo_producto = dlg.pecProducto.select(model.get_value(it, DESCRIPCION_PRODUCTO), 1)
        dlg.spnCantidad.set_value(float(model.get_value(it, CANTIDADO_EMBOTELLADO)))
        dlg.entLote.set_text(model.get_value(it, LOTE))
       
        fecha = comunes.GetDateFromModel(model.get_value(it, FECHA).split()[0])
        try:
            hora = model.get_value(it, HORA).split(":")[0] + ":" + model.get_value(it, HORA).split(":")[1]
        except:
            hora = ""
        
        dlg.entFecha.set_date(fecha)
        dlg.entHora.set_text(hora)

        if model.get_value(it, CANTIDAD_BOTELLA) not in('',None):
            dlg.spnCantidadB.set_value(float(model.get_value(it, CANTIDAD_BOTELLA)))
        
        buf = dlg.txtObservacion.get_buffer()
        if len(model[0]) > OBSERVACION:
            texto = model.get_value(it, OBSERVACION)
        else:
            texto = ""
            
        if texto is None:
            texto = ""
        buf.set_text(texto)
        
        dlg.txtObservacion.set_buffer(buf)
        
        dlg.aplicacion.carga_modelo(model.get_value(it, CODIGO_EMBOTELLADO), "embotellado")
        dlg.control.carga_modelo(model.get_value(it, CODIGO_EMBOTELLADO), "embotellado")
        
        dlg.relacion.carga_modelo(model.get_value(it, CODIGO_EMBOTELLADO))
        
        dlg.entTemporada.set_text(model.get_value(it, DESCRIPCION_TEMPORADA))
        dlg.codigo_temporada = model.get_value(it, CODIGO_TEMPORADA)
        dlg.pecTemporada.set_selected(True)
        
        dlg.editando = True
        
        response = dlg.dlgEmbotellado.run()
        if response == gtk.RESPONSE_OK:
            self.modelo.clear()
            self.carga_datos()
            
    def on_btnCerrar_clicked(self, btn=None):
        if self.padre is None:
            self.on_exit()
        else:
            self.padre.remove_tab("Embotellado")
            
    def on_treeProceso_row_activated(self, tree=None, path=None, col=None):
        self.on_btnPropiedades_clicked()


class dlgEmbotellado(GladeConnect):
    
    def __init__(self, conexion=None, padre=None, editando=None, codigo_embotellado=None):
        GladeConnect.__init__(self, "glade/wnProceso.glade", "dlgEmbotellado")
        self.cnx = conexion
        self.cursor = self.cnx.cursor()
        self.editando = editando
        self.frm_padre = padre
        self.codigo_producto = None
        
        self.pecProducto = completion.CompletionProducto(self.entProducto,
                self.sel_producto,
                self.cnx)
        
        self.aplicacion = proceso.vboxAplicacion(self.cnx, self)
        self.ntbEmbotellado.append_page(self.aplicacion.vboxAplicacion, gtk.Label("Insumos"))
        
        self.control = proceso.vboxControl(self.cnx, self)
        self.ntbEmbotellado.append_page(self.control.vboxControl, gtk.Label("Control"))
        
        self.relacion = proceso.vboxEmbotelladoMezcla(self.cnx, self)
        self.ntbEmbotellado.append_page(self.relacion.vboxRelacion, gtk.Label("Detalle Mezcla"))
        
        self.pecTemporada = completion.CompletionTemporada(self.entTemporada,
                self.sel_temporada,
                self.cnx)
        
        #<CODIGO comment="PARA SUGERIR LA MAS NUEVA">
        strSelectCodigoTemporada = """SELECT
                                        codigo_temporada,
                                        'Temporada ' || date_part('year', fecha_inicio) || '-' 
                                        || date_part('year', fecha_termino) as descripcion_temporada
                                        FROM traza.temporada
                                        WHERE abierta = TRUE
                                        ORDER BY codigo_temporada desc"""
                                        
        m = ifd.ListStoreFromSQL(self.cnx, strSelectCodigoTemporada)
        self.codigo_temporada = m[0][0]
        self.entTemporada.set_text(m[0][1])
        self.pecTemporada.set_selected(True)
        #</CODIGO>
        
        self.dlgEmbotellado.show_all()

    def sel_producto(self, completion, model, iter):
        self.codigo_producto = model.get_value(iter, 1)
    
    def sel_temporada(self, completion, model, iter):
        self.codigo_temporada = model.get_value(iter, 1)
        
    def on_btnAceptar_clicked(self, btn=None, date=None, cnx=None):

        fecha = self.entFecha.get_date()
        
        if self.codigo_producto is None:
            dialogos.error("Debe escoger un <b>Producto</b>")
            return
       
       
        hora = self.entHora.get_text()
        
        if hora == "":
            dialogos.error("El campo <b>Hora</b> no puede estar vacío")
            return
        
        cantidad = self.spnCantidad.get_value()
        cantidadB = self.spnCantidadB.get_value()
        
        if cantidad <= 0:
            dialogos.error("La <b>cantidad</b> debe ser mayor que 0")
            return
                
        if cantidadB <= 0:
            dialogos.error("El campo <b>Cantidad de Botella</b> debe ser mayor que 0")
            return
        
        if self.entTemporada.get_text() == "":
            dialogos.error("La temporada no puede ser vacia.")
            return
        
        campos = {}
        llaves = {}
        campos['codigo_producto'] = self.codigo_producto
        campos['lote'] = self.entLote.get_text().upper()
        campos['cantidad'] = cantidad
        campos['fecha'] = fecha.strftime("%Y/%m/%d")
        campos['hora'] = hora
        campos['cantidad_botella'] = cantidadB 
        campos['codigo_temporada'] = self.codigo_temporada
        
        buf = self.txtObservacion.get_buffer()
        s, e = buf.get_bounds()
        if str(buf.get_text(s, e)) != "None" and str(buf.get_text(s, e)) != "":
            campos['orden_trabajo'] = buf.get_text(s, e)
        else:
            buf.set_text("")
            campos['orden_trabajo'] = buf.get_text(s, e)
        
        self.cursor.execute("BEGIN")
        
        try:
        
            if not self.editando:
                self.cursor.execute(strNextValCodigo % ("embotellado", "embotellado"))
                reg = self.cursor.fetchone()
                campos['codigo_embotellado'] = reg[0]
                llaves['codigo_embotellado'] = reg[0]
                sql = ifd.insertFromDict("traza.embotellado", campos)
            else:
                llaves['codigo_embotellado'] = self.entCodigoEmbotellado.get_text()
                sql, campos=ifd.updateFromDict("traza.embotellado", campos, llaves)
    
            self.cursor.execute(sql, campos)
            self.aplicacion.guarda_modelo(llaves['codigo_embotellado'], "embotellado")
            self.control.guarda_modelo(llaves['codigo_embotellado'], "embotellado")
            self.relacion.guarda_modelo("traza.mezcla_embotellado", "codigo_embotellado", llaves['codigo_embotellado'], "codigo_mezcla")
            #self.detalle.guarda_modelo("traza.detalle_embotellado", "codigo_embotellado", llaves['codigo_embotellado'], "codigo_relacion")
        except:
            txt_error = sys.exc_info()[1]
            self.cursor.execute("ROLLBACK")
            dialogos.error("Ha ocurrido un error al intentar registrar los datos", str(txt_error))
            return
            
        self.cursor.execute("COMMIT")
        
        self.dlgEmbotellado.hide()
        
    def on_btnCancelar_clicked(self, btn=None):
        self.dlgEmbotellado.hide()
        
if __name__ == '__main__':
    cnx = connect("dbname=traza user=traza password=123 host=localhost")
    #cnx.autocommit()
    sys.excepthook = debugwindow.show
    d = wnEmbotellado(cnx)
    
    gtk.main()
